പൈത്തൺ ഉപയോഗിച്ച് തുടക്കം മുതൽ സുരക്ഷിതമായ ഒരു ക്രിപ്‌റ്റോകറൻസി വാലറ്റ് നിർമ്മിക്കാൻ പഠിക്കുക. ഈ ഗൈഡ് പ്രധാന ആശയങ്ങൾ, ക്രിപ്റ്റോഗ്രഫി, ലൈബ്രറികൾ, കോഡ് ഉദാഹരണങ്ങൾ എന്നിവ വിശദീകരിക്കുന്നു.
പൈത്തൺ ഉപയോഗിച്ച് ഒരു ക്രിപ്‌റ്റോകറൻസി വാലറ്റ് നിർമ്മിക്കാം: ഒരു സമഗ്രമായ ഗൈഡ്
വേഗത്തിൽ മാറിക്കൊണ്ടിരിക്കുന്ന ഡിജിറ്റൽ ഫിനാൻസിന്റെ ലോകത്ത്, ക്രിപ്‌റ്റോകറൻസികൾ ഒരു വലിയ മാറ്റത്തിന് കാരണമായിരിക്കുന്നു. ഈ വിപ്ലവത്തിന്റെ ഹൃദയഭാഗത്ത് വാലറ്റ് എന്ന ആശയമാണ്—ബ്ലോക്ക്ചെയിൻ നെറ്റ്‌വർക്കുകളുമായി സംവദിക്കാനുള്ള നിങ്ങളുടെ വ്യക്തിഗത കവാടം. നിരവധി വാണിജ്യ വാലറ്റുകൾ നിലവിലുണ്ടെങ്കിലും, അവ എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് ആഴത്തിൽ മനസ്സിലാക്കുന്നത് ഏതൊരു ഡെവലപ്പർക്കും സാങ്കേതികവിദ്യാ തത്പരർക്കും വിലയേറിയ ഒരു കഴിവാണ്. ഈ ഗൈഡ് പൈത്തൺ ഉപയോഗിച്ച് തുടക്കം മുതൽ പ്രവർത്തനക്ഷമമായ ഒരു ക്രിപ്‌റ്റോകറൻസി വാലറ്റ് നിർമ്മിക്കുന്നതിലൂടെ ഈ പ്രക്രിയയെ ലളിതമാക്കും.
അടിസ്ഥാനപരമായ ക്രിപ്റ്റോഗ്രാഫിക് തത്വങ്ങൾ, ആവശ്യമായ പൈത്തൺ ലൈബ്രറികൾ, കീകൾ നിർമ്മിക്കുന്നതിനും, ബിറ്റ്കോയിനിനും എതെറിയത്തിനും വേണ്ടിയുള്ള അഡ്രസ്സുകൾ ഉണ്ടാക്കുന്നതിനും, ഇടപാടുകളിൽ ഒപ്പുവെക്കുന്നതിനും വേണ്ടിയുള്ള ഘട്ടം ഘട്ടമായുള്ള നിർമ്മാണ രീതിയും നമ്മൾ ഇവിടെ ചർച്ച ചെയ്യും. ഈ ലേഖനം അവസാനിക്കുമ്പോൾ, വാലറ്റിന്റെ പ്രവർത്തനങ്ങളെക്കുറിച്ച് നിങ്ങൾക്ക് വ്യക്തമായ ധാരണയും സ്വന്തമായി ഒരു കമാൻഡ്-ലൈൻ വാലറ്റും ഉണ്ടായിരിക്കും.
നിരാകരണം: ഈ ഗൈഡിൽ നൽകിയിരിക്കുന്ന കോഡും ആശയങ്ങളും വിദ്യാഭ്യാസപരമായ ആവശ്യങ്ങൾക്ക് മാത്രമുള്ളതാണ്. ഒരു പ്രൊഡക്ഷൻ-ഗ്രേഡ് വാലറ്റ് നിർമ്മിക്കുന്നതിന് കർശനമായ സുരക്ഷാ പരിശോധനകൾ, വിപുലമായ ടെസ്റ്റിംഗ്, നൂതന സുരക്ഷാ നടപടികൾ എന്നിവ ആവശ്യമാണ്. യഥാർത്ഥ ഫണ്ടുകൾ സംഭരിക്കാൻ ഇവിടെ നിർമ്മിച്ച വാലറ്റ് ഉപയോഗിക്കരുത്.
ഒരു ക്രിപ്‌റ്റോകറൻസി വാലറ്റിന്റെ പ്രധാന ആശയങ്ങൾ മനസ്സിലാക്കാം
നമ്മൾ ഒരു വരി കോഡ് എഴുതുന്നതിന് മുമ്പ്, ഒരു ക്രിപ്‌റ്റോകറൻസി വാലറ്റ് യഥാർത്ഥത്തിൽ എന്താണെന്ന് മനസ്സിലാക്കേണ്ടത് അത്യാവശ്യമാണ്. പേര് സൂചിപ്പിക്കുന്നതുപോലെയല്ല, ഒരു വാലറ്റ് നിങ്ങളുടെ കോയിനുകൾ "സംഭരിക്കുന്നില്ല". നിങ്ങളുടെ ക്രിപ്‌റ്റോകറൻസി ഒരു വിതരണ ലെഡ്ജറായ—ബ്ലോക്ക്ചെയിനിലെ രേഖകളായാണ് നിലനിൽക്കുന്നത്. ഒരു വാലറ്റ് എന്നത് ആ ലെഡ്ജറിലെ നിങ്ങളുടെ ആസ്തികളുടെ ഉടമസ്ഥാവകാശവും നിയന്ത്രണവും നൽകുന്ന ക്രിപ്റ്റോഗ്രാഫിക് കീകൾ കൈകാര്യം ചെയ്യുന്ന ഒരു സോഫ്റ്റ്‌വെയറാണ്.
ഏതൊരു നോൺ-കസ്റ്റോഡിയൽ വാലറ്റിന്റെയും പ്രാഥമിക ഘടകങ്ങൾ ഇവയാണ്:
1. പ്രൈവറ്റ് കീകൾ: നിങ്ങളുടെ ഡിജിറ്റൽ രഹസ്യം
ഒരു പ്രൈവറ്റ് കീ ആണ് നിങ്ങളുടെ വാലറ്റിലെ ഏറ്റവും നിർണ്ണായകമായ വിവരം. ഇത് വളരെ വലുതും ക്രമരഹിതമായി ജനറേറ്റ് ചെയ്തതുമായ ഒരു സംഖ്യയാണ്, അത് രഹസ്യമായി സൂക്ഷിക്കുകയും നിങ്ങൾക്ക് മാത്രം അറിയുകയും ചെയ്യും. ഇതിന്റെ ഉദ്ദേശ്യം ഒരു ഡിജിറ്റൽ സിഗ്നേച്ചർ ഉണ്ടാക്കുക എന്നതാണ്, ഇത് നിങ്ങൾ ഒരു ഇടപാട് അംഗീകരിച്ചു എന്നതിന്റെ无可辩驳മായ തെളിവായി വർത്തിക്കുന്നു. നിങ്ങളുടെ പ്രൈവറ്റ് കീ നഷ്ടപ്പെട്ടാൽ, നിങ്ങളുടെ ഫണ്ടുകളിലേക്കുള്ള പ്രവേശനം എന്നെന്നേക്കുമായി നഷ്ടപ്പെടും. മറ്റൊരാൾക്ക് ഇതിലേക്ക് പ്രവേശനം ലഭിച്ചാൽ, അവർക്ക് നിങ്ങളുടെ ഫണ്ടുകളുടെ പൂർണ്ണ നിയന്ത്രണം ലഭിക്കും.
- സാമ്യം: ഒരു പ്രൈവറ്റ് കീയെ നിങ്ങളുടെ ഡിജിറ്റൽ നിലവറയുടെ മാസ്റ്റർ കീ ആയി കരുതുക. അതിന് നിലവറ തുറക്കാനും അതിലെ ഉള്ളടക്കങ്ങളുടെ നീക്കത്തിന് അംഗീകാരം നൽകാനും കഴിയും.
2. പബ്ലിക് കീകൾ: നിങ്ങളുടെ പങ്കുവെക്കാവുന്ന ഐഡന്റിഫയർ
ഒരു പബ്ലിക് കീ നിങ്ങളുടെ പ്രൈവറ്റ് കീയിൽ നിന്ന് എലിപ്റ്റിക് കർവ് ക്രിപ്റ്റോഗ്രഫി (ECC) എന്നറിയപ്പെടുന്ന ഒരു വൺ-വേ ക്രിപ്റ്റോഗ്രാഫിക് ഫംഗ്ഷൻ ഉപയോഗിച്ച് ഗണിതശാസ്ത്രപരമായി ഉരുത്തിരിഞ്ഞതാണ്. ഒരു പ്രൈവറ്റ് കീയിൽ നിന്ന് ഒരു പബ്ലിക് കീ ജനറേറ്റ് ചെയ്യാൻ സാധിക്കുമെങ്കിലും, അതിന്റെ വിപരീതം കമ്പ്യൂട്ടേഷണലായി അസാധ്യമാണ്. ഈ വൺ-വേ ബന്ധമാണ് ക്രിപ്‌റ്റോകറൻസി സുരക്ഷയുടെ അടിസ്ഥാനം.
- സാമ്യം: ഒരു പബ്ലിക് കീ നിങ്ങളുടെ ബാങ്ക് അക്കൗണ്ട് നമ്പർ പോലെയാണ്. മറ്റുള്ളവർക്ക് പണം അയക്കാൻ നിങ്ങൾക്ക് അത് പങ്കിടാം, എന്നാൽ അത് അവർക്ക് ഫണ്ട് പിൻവലിക്കാനുള്ള കഴിവ് നൽകുന്നില്ല.
3. അഡ്രസ്സുകൾ: നിങ്ങളുടെ പൊതുവായ ലക്ഷ്യസ്ഥാനം
ഒരു വാലറ്റ് അഡ്രസ്സ് നിങ്ങളുടെ പബ്ലിക് കീയുടെ ചെറുതും കൂടുതൽ ഉപയോക്തൃ-സൗഹൃദവുമായ ഒരു രൂപമാണ്. ഇത് പബ്ലിക് കീയിൽ അധിക ഹാഷിംഗ് അൽഗോരിതങ്ങൾ (SHA-256, RIPEMD-160 പോലുള്ളവ) പ്രയോഗിച്ച് ജനറേറ്റ് ചെയ്യുന്നു, കൂടാതെ ഫണ്ടുകൾ അയക്കുമ്പോൾ ഉണ്ടാകുന്ന ടൈപ്പിംഗ് പിശകുകൾ തടയാൻ ഒരു ചെക്ക്സവും പലപ്പോഴും ഇതിൽ ഉൾപ്പെടുന്നു. ക്രിപ്‌റ്റോകറൻസി സ്വീകരിക്കുന്നതിന് നിങ്ങൾ മറ്റുള്ളവരുമായി പങ്കിടുന്ന പ്രതീകങ്ങളുടെ ഒരു സ്ട്രിംഗ് ആണിത്.
- സാമ്യം: പബ്ലിക് കീ നിങ്ങളുടെ അക്കൗണ്ട് നമ്പർ ആണെങ്കിൽ, അഡ്രസ്സ് എന്നത് പിശകുകൾ പരിശോധിക്കുന്നതിനുള്ള സവിശേഷതകൾ ഉൾക്കൊള്ളുന്ന ഒരു പ്രത്യേക, ഫോർമാറ്റ് ചെയ്ത ഇൻവോയ്സ് നമ്പർ പോലെയാണ്.
4. ക്രിപ്റ്റോഗ്രാഫിക് ലിങ്ക്: ഒരു വൺ-വേ സ്ട്രീറ്റ്
ഈ ഘടകങ്ങൾ തമ്മിലുള്ള ബന്ധം കർശനമായ, വൺ-വേ ശ്രേണിയാണ്:
പ്രൈവറ്റ് കീ → പബ്ലിക് കീ → അഡ്രസ്സ്
നിങ്ങളുടെ പബ്ലിക് കീ നേരിട്ട് വെളിപ്പെടുത്താതെയും (ചില സാഹചര്യങ്ങളിൽ) തീർച്ചയായും നിങ്ങളുടെ പ്രൈവറ്റ് കീ വെളിപ്പെടുത്താതെയും നിങ്ങളുടെ അഡ്രസ്സ് സുരക്ഷിതമായി പങ്കിടാൻ കഴിയുമെന്ന് ഈ ഡിസൈൻ ഉറപ്പാക്കുന്നു.
5. ഡിജിറ്റൽ സിഗ്നേച്ചറുകൾ: ഉടമസ്ഥാവകാശത്തിന്റെ തെളിവ്
നിങ്ങൾ ക്രിപ്‌റ്റോകറൻസി അയയ്‌ക്കാൻ ആഗ്രഹിക്കുമ്പോൾ, നിങ്ങൾ ഒരു ഇടപാട് സന്ദേശം സൃഷ്‌ടിക്കുന്നു (ഉദാഹരണത്തിന്, "അഡ്രസ്സ് A-ൽ നിന്ന് അഡ്രസ്സ് B-ലേക്ക് 0.5 BTC അയയ്‌ക്കുക"). നിങ്ങളുടെ വാലറ്റ് സോഫ്റ്റ്‌വെയർ ആ നിർദ്ദിഷ്‌ട ഇടപാടിനായി ഒരു അദ്വിതീയ ഡിജിറ്റൽ സിഗ്നേച്ചർ സൃഷ്‌ടിക്കാൻ നിങ്ങളുടെ പ്രൈവറ്റ് കീ ഉപയോഗിക്കുന്നു. ഈ സിഗ്നേച്ചർ ഇടപാടിനൊപ്പം നെറ്റ്‌വർക്കിലേക്ക് പ്രക്ഷേപണം ചെയ്യപ്പെടുന്നു. നെറ്റ്‌വർക്കിലെ മൈനർമാർക്കും നോഡുകൾക്കും സിഗ്നേച്ചർ സാധുവാണോ എന്ന് പരിശോധിക്കാൻ നിങ്ങളുടെ പബ്ലിക് കീ ഉപയോഗിക്കാം, ഇത് നിങ്ങളുടെ പ്രൈവറ്റ് കീ കാണാതെ തന്നെ ഫണ്ടിന്റെ യഥാർത്ഥ ഉടമയാണ് ഇടപാടിന് അംഗീകാരം നൽകിയതെന്ന് സ്ഥിരീകരിക്കുന്നു.
നിങ്ങളുടെ പൈത്തൺ ഡെവലപ്‌മെന്റ് എൻവയോൺമെന്റ് സജ്ജീകരിക്കുന്നു
നമ്മുടെ വാലറ്റ് നിർമ്മിക്കുന്നതിന്, സങ്കീർണ്ണമായ ക്രിപ്റ്റോഗ്രഫി കൈകാര്യം ചെയ്യുന്ന ചില പ്രത്യേക പൈത്തൺ ലൈബ്രറികൾ നമുക്ക് ആവശ്യമാണ്. നിങ്ങളുടെ കമ്പ്യൂട്ടറിൽ പൈത്തൺ 3.6 അല്ലെങ്കിൽ പുതിയ പതിപ്പ് ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുക. പിപ്പ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് ആവശ്യമായ പാക്കേജുകൾ ഇൻസ്റ്റാൾ ചെയ്യാൻ കഴിയും:
pip install ecdsa pysha3 base58
ഓരോ ലൈബ്രറിയും എന്താണ് ചെയ്യുന്നതെന്ന് നമുക്ക് നോക്കാം:
- ecdsa: എലിപ്റ്റിക് കർവ് ഡിജിറ്റൽ സിഗ്നേച്ചർ അൽഗോരിതം (ECDSA) നടപ്പിലാക്കുന്നതിനുള്ള ഒരു നിർണ്ണായക ലൈബ്രറിയാണിത്. ബിറ്റ്കോയിൻ, എതെറിയം, മറ്റ് നിരവധി ക്രിപ്‌റ്റോകറൻസികൾ ഉപയോഗിക്കുന്ന സ്റ്റാൻഡേർഡായ
SECP256k1കർവ് അടിസ്ഥാനമാക്കി പ്രൈവറ്റ്, പബ്ലിക് കീകൾ നിർമ്മിക്കാൻ നമ്മൾ ഇത് ഉപയോഗിക്കും. ഡിജിറ്റൽ സിഗ്നേച്ചറുകളുടെ നിർമ്മാണവും പരിശോധനയും ഇത് കൈകാര്യം ചെയ്യുന്നു. - pysha3: പൈത്തണിന്റെ ബിൽറ്റ്-ഇൻ
hashlibപല ഹാഷിംഗ് അൽഗോരിതങ്ങളെയും പിന്തുണയ്ക്കുന്നുണ്ടെങ്കിലും, എതെറിയം അഡ്രസ്സുകൾ നിർമ്മിക്കുന്നതിന് ആവശ്യമായ Keccak-256 ഇതിൽ ഉൾപ്പെടുത്തിയിട്ടില്ല. ഈ ലൈബ്രറി ആ പ്രവർത്തനം നൽകുന്നു. - base58: ഈ ലൈബ്രറി Base58Check എൻകോഡിംഗ് നടപ്പിലാക്കുന്നു, ഇത് മനുഷ്യർക്ക് വായിക്കാൻ കഴിയുന്ന ബിറ്റ്കോയിൻ അഡ്രസ്സുകൾ നിർമ്മിക്കാൻ ഉപയോഗിക്കുന്ന ഒരു ഫോർമാറ്റാണ്. ടൈപ്പിംഗിൽ നിന്നുള്ള പിശകുകൾ തടയാൻ സഹായിക്കുന്നതിന് ഇതിൽ ഒരു ചെക്ക്സം ഉൾപ്പെടുന്നു.
- hashlib: ഈ ബിൽറ്റ്-ഇൻ പൈത്തൺ ലൈബ്രറി SHA-256, RIPEMD-160 ഹാഷിംഗിനായി ഉപയോഗിക്കും, ഇത് ഒരു ബിറ്റ്കോയിൻ അഡ്രസ്സ് നിർമ്മിക്കുന്നതിലെ പ്രധാന ഘട്ടങ്ങളാണ്.
ഘട്ടം ഘട്ടമായുള്ള നിർവ്വഹണം: വാലറ്റ് ലോജിക് നിർമ്മിക്കുന്നു
ഇനി, നമുക്ക് കോഡിലേക്ക് കടക്കാം. നമ്മുടെ വാലറ്റിന്റെ പ്രധാന പ്രവർത്തനങ്ങൾ ഓരോന്നായി നിർമ്മിക്കുകയും ഓരോ ഘട്ടവും വിശദീകരിക്കുകയും ചെയ്യും.
ഘട്ടം 1: ഒരു പ്രൈവറ്റ് കീ നിർമ്മിക്കുന്നു
ഒരു പ്രൈവറ്റ് കീ അടിസ്ഥാനപരമായി 256-ബിറ്റ് (32-ബൈറ്റ്) സംഖ്യയാണ്. ഏറ്റവും പ്രധാനപ്പെട്ട ആവശ്യം അത് യഥാർത്ഥ റാൻഡംനെസ്സ് ഉപയോഗിച്ച് നിർമ്മിക്കണം എന്നതാണ്. ദുർബലമായ ഒരു റാൻഡം നമ്പർ ജനറേറ്റർ ഉപയോഗിക്കുന്നത് ഒരു ആക്രമണകാരിക്ക് ഊഹിക്കാൻ കഴിയുന്ന പ്രവചനാതീതമായ കീകൾക്ക് കാരണമാകും.
പൈത്തണിന്റെ ബിൽറ്റ്-ഇൻ secrets മൊഡ്യൂൾ ക്രിപ്റ്റോഗ്രാഫിക്കലി സുരക്ഷിതമായ റാൻഡം നമ്പറുകൾ നിർമ്മിക്കുന്നതിനായി രൂപകൽപ്പന ചെയ്തിട്ടുള്ളതാണ്, ഇത് നമ്മുടെ ആവശ്യങ്ങൾക്ക് തികച്ചും അനുയോജ്യമാണ്.
ഇവിടെ, `os.urandom(32)` 32 ക്രിപ്റ്റോഗ്രാഫിക്കലി സുരക്ഷിതമായ റാൻഡം ബൈറ്റുകൾ നൽകുന്നു, ഇത് 256-ബിറ്റ് പ്രൈവറ്റ് കീക്ക് നമുക്ക് കൃത്യമായി ആവശ്യമുള്ളതാണ്.
ഘട്ടം 2: പബ്ലിക് കീ ഉരുത്തിരിച്ചെടുക്കുന്നു
അടുത്തതായി, `SECP256k1` എലിപ്റ്റിക് കർവ് ഉപയോഗിച്ച് പ്രൈവറ്റ് കീയിൽ നിന്ന് നമ്മൾ പബ്ലിക് കീ ഉരുത്തിരിച്ചെടുക്കുന്നു. `ecdsa` ലൈബ്രറി ഈ പ്രക്രിയ ലളിതമാക്കുന്നു.
```python def private_key_to_public_key(private_key_bytes): """ഒരു പ്രൈവറ്റ് കീയെ അതിന് അനുയോജ്യമായ പബ്ലിക് കീ ആക്കി മാറ്റുക.""" # SECP256k1 ബിറ്റ്കോയിനും എതെറിയവും ഉപയോഗിക്കുന്ന കർവ് ആണ് sk = ecdsa.SigningKey.from_string(private_key_bytes, curve=ecdsa.SECP256k1) # പബ്ലിക് കീയെ അൺകംപ്രസ്ഡ് ഫോർമാറ്റിൽ നേടുക (0x04-ൽ ആരംഭിക്കുന്നു) vk = sk.verifying_key public_key_bytes = vk.to_string("uncompressed") return public_key_bytes ````ecdsa.SigningKey` ഒബ്ജക്റ്റ് നമ്മുടെ പ്രൈവറ്റ് കീയെ പ്രതിനിധീകരിക്കുന്നു. തുടർന്ന് നമ്മൾ അതിനനുയോജ്യമായ `verifying_key` (പബ്ലിക് കീ) നേടുകയും അതിനെ "uncompressed" ഫോർമാറ്റിൽ എക്സ്പോർട്ട് ചെയ്യുകയും ചെയ്യുന്നു. ഒരു അൺകംപ്രസ്ഡ് പബ്ലിക് കീക്ക് 65 ബൈറ്റ് നീളമുണ്ട്: ഒരു `0x04` പ്രിഫിക്‌സും, തുടർന്ന് 32-ബൈറ്റ് X കോർഡിനേറ്റും എലിപ്റ്റിക് കർവിലെ ഒരു പോയിന്റിന്റെ 32-ബൈറ്റ് Y കോർഡിനേറ്റും.
ഘട്ടം 3: ഒരു ബിറ്റ്കോയിൻ അഡ്രസ്സ് നിർമ്മിക്കുന്നു
ഒരു പബ്ലിക് കീയിൽ നിന്ന് ഒരു ബിറ്റ്കോയിൻ അഡ്രസ്സ് നിർമ്മിക്കുന്നത് സുരക്ഷയ്ക്കും പിശക് പരിശോധനയ്ക്കുമായി രൂപകൽപ്പന ചെയ്ത ഒരു ബഹുഘട്ട പ്രക്രിയയാണ്. സ്റ്റാൻഡേർഡ് P2PKH (Pay-to-Public-Key-Hash) അഡ്രസ്സ് നിർമ്മാണ രീതി താഴെ നൽകുന്നു:
- SHA-256 ഹാഷിംഗ്: പബ്ലിക് കീയെ SHA-256 ഉപയോഗിച്ച് ഹാഷ് ചെയ്യുക.
- RIPEMD-160 ഹാഷിംഗ്: മുൻ ഘട്ടത്തിലെ ഫലത്തെ RIPEMD-160 ഉപയോഗിച്ച് ഹാഷ് ചെയ്യുക.
- വേർഷൻ ബൈറ്റ് ചേർക്കുക: RIPEMD-160 ഹാഷിലേക്ക് ഒരു വേർഷൻ ബൈറ്റ് പ്രിഫിക്സ് ചേർക്കുക. ബിറ്റ്കോയിൻ മെയിൻനെറ്റിനായി ഇത് `0x00` ആണ്.
- ചെക്ക്സം കണക്കുകൂട്ടൽ: വിപുലീകരിച്ച ഹാഷിൽ രണ്ടുതവണ SHA-256 ഹാഷിംഗ് നടത്തുക, അവസാന ഹാഷിന്റെ ആദ്യത്തെ 4 ബൈറ്റുകൾ എടുക്കുക. ഇതാണ് ചെക്ക്സം.
- ചെക്ക്സം കൂട്ടിച്ചേർക്കുക: വേർഷൻ പ്രിഫിക്സ് ചെയ്ത ഹാഷിന്റെ അവസാനത്തിൽ 4-ബൈറ്റ് ചെക്ക്സം ചേർക്കുക.
- Base58Check എൻകോഡിംഗ്: മുഴുവൻ ബൈറ്റ് സ്ട്രിംഗും Base58Check ഉപയോഗിച്ച് എൻകോഡ് ചെയ്ത് അവസാനത്തെ, മനുഷ്യർക്ക് വായിക്കാവുന്ന അഡ്രസ്സ് നേടുക.
ഇത് പൈത്തണിൽ നടപ്പിലാക്കാം:
```python def public_key_to_btc_address(public_key_bytes): """ഒരു പബ്ലിക് കീയെ ഒരു ബിറ്റ്കോയിൻ P2PKH അഡ്രസ്സാക്കി മാറ്റുക.""" # ഘട്ടം 1 & 2: SHA-256, തുടർന്ന് RIPEMD-160 sha256_hash = hashlib.sha256(public_key_bytes).digest() ripemd160_hash = hashlib.new('ripemd160') ripemd160_hash.update(sha256_hash) hashed_public_key = ripemd160_hash.digest() # ഘട്ടം 3: വേർഷൻ ബൈറ്റ് ചേർക്കുക (മെയിൻനെറ്റിനായി 0x00) version_byte = b'\x00' versioned_hash = version_byte + hashed_public_key # ഘട്ടം 4 & 5: ചെക്ക്സം നിർമ്മിച്ച് കൂട്ടിച്ചേർക്കുക # ഡബിൾ SHA-256 ഹാഷ് checksum_hash_1 = hashlib.sha256(versioned_hash).digest() checksum_hash_2 = hashlib.sha256(checksum_hash_1).digest() checksum = checksum_hash_2[:4] binary_address = versioned_hash + checksum # ഘട്ടം 6: Base58Check എൻകോഡ് ചെയ്യുക btc_address = base58.b58encode(binary_address).decode('utf-8') return btc_address ```ഘട്ടം 4: ഒരു എതെറിയം അഡ്രസ്സ് നിർമ്മിക്കുന്നു
ബിറ്റ്കോയിനുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ ഒരു എതെറിയം അഡ്രസ്സ് നിർമ്മിക്കുന്നത് ലളിതമാണ്. ഇതിൽ പബ്ലിക് കീയുടെ Keccak-256 ഹാഷ് എടുക്കുകയും ഫലത്തിന്റെ അവസാന 20 ബൈറ്റുകൾ ഉപയോഗിക്കുകയും ചെയ്യുന്നു.
- Keccak-256 ഹാഷിംഗ്: പബ്ലിക് കീയുടെ Keccak-256 ഹാഷ് എടുക്കുക. നമ്മൾ `0x04` പ്രിഫിക്സ് *ഇല്ലാത്ത* പബ്ലിക് കീ ഉപയോഗിക്കണം എന്നത് ശ്രദ്ധിക്കുക.
- അവസാന 20 ബൈറ്റുകൾ എടുക്കുക: ഈ ഹാഷിന്റെ അവസാന 20 ബൈറ്റുകളാണ് (40 ഹെക്സ് പ്രതീകങ്ങൾ) എതെറിയം അഡ്രസ്സ്.
- ഫോർമാറ്റ്: അഡ്രസ്സിന് `0x` പ്രിഫിക്സ് നൽകുന്നത് സാധാരണമാണ്.
`pysha3` ഉപയോഗിച്ച് ഇത് നടപ്പിലാക്കാം:
```python def public_key_to_eth_address(public_key_bytes): """ഒരു പബ്ലിക് കീയെ ഒരു എതെറിയം അഡ്രസ്സാക്കി മാറ്റുക.""" # എതെറിയം അഡ്രസ്സ് നിർമ്മാണത്തിന് 0x04 പ്രിഫിക്സ് ഇല്ലാത്ത അൺകംപ്രസ്ഡ് പബ്ലിക് കീയാണ് ഉപയോഗിക്കുന്നത് uncompressed_pk = public_key_bytes[1:] # ഘട്ടം 1: Keccak-256 ഹാഷ് keccak_hash = keccak_256(uncompressed_pk).digest() # ഘട്ടം 2: അവസാന 20 ബൈറ്റുകൾ എടുക്കുക eth_address_bytes = keccak_hash[-20:] # ഘട്ടം 3: '0x' പ്രിഫിക്സ് ഉപയോഗിച്ച് ഫോർമാറ്റ് ചെയ്യുക eth_address = '0x' + eth_address_bytes.hex() return eth_address ```ഘട്ടം 5: ഒരു സന്ദേശത്തിൽ ഒപ്പുവെക്കുന്നു
ഒരു ഡിജിറ്റൽ സിഗ്നേച്ചർ ഒരു പ്രൈവറ്റ് കീയുടെ ഉടമ ഒരു സന്ദേശത്തിന് (ഒരു ഇടപാട് പോലുള്ളവ) അംഗീകാരം നൽകി എന്ന് തെളിയിക്കുന്നു. കാര്യക്ഷമതയ്ക്കും സുരക്ഷയ്ക്കുമായി, റോ സന്ദേശത്തിൽ ഒപ്പുവെക്കുന്നതിനുപകരം സന്ദേശത്തിന്റെ ഹാഷിൽ ഒപ്പുവെക്കുന്നതാണ് ഈ പ്രക്രിയയിൽ ഉൾപ്പെടുന്നത്.
```python def sign_message(private_key_bytes, message): """നൽകിയിരിക്കുന്ന പ്രൈവറ്റ് കീ ഉപയോഗിച്ച് ഒരു സന്ദേശത്തിൽ ഒപ്പുവെക്കുക.""" # സന്ദേശത്തിന്റെ ഹാഷിൽ ഒപ്പുവെക്കുന്നതാണ് സാധാരണ രീതി message_hash = hashlib.sha256(message.encode('utf-8')).digest() sk = ecdsa.SigningKey.from_string(private_key_bytes, curve=ecdsa.SECP256k1) signature = sk.sign(message_hash) return signature ```ഘട്ടം 6: ഒരു സിഗ്നേച്ചർ പരിശോധിക്കുന്നു
പരിശോധന വിപരീത പ്രക്രിയയാണ്. പബ്ലിക് കീയും, യഥാർത്ഥ സന്ദേശവും, സിഗ്നേച്ചറും ഉള്ള ആർക്കും സിഗ്നേച്ചർ യഥാർത്ഥമാണോ എന്ന് സ്ഥിരീകരിക്കാൻ കഴിയും. ബ്ലോക്ക്ചെയിൻ നെറ്റ്‌വർക്ക് ഇടപാടുകൾ സാധൂകരിക്കുന്നത് ഇങ്ങനെയാണ്.
```python def verify_signature(public_key_bytes, signature, message): """നൽകിയിട്ടുള്ള പബ്ലിക് കീ ഉപയോഗിച്ച് ഒരു സന്ദേശത്തിനുള്ള സിഗ്നേച്ചർ പരിശോധിക്കുക.""" message_hash = hashlib.sha256(message.encode('utf-8')).digest() vk = ecdsa.VerifyingKey.from_string(public_key_bytes, curve=ecdsa.SECP256k1, hashfunc=hashlib.sha256) try: # സാധുവാണെങ്കിൽ verify മെത്തേഡ് True നൽകും, അല്ലെങ്കിൽ ഒരു എക്സെപ്ഷൻ നൽകും return vk.verify(signature, message_hash) except ecdsa.BadSignatureError: return False ```വാലറ്റ് ഒരുമിപ്പിക്കുന്നു: ഒരു ലളിതമായ കമാൻഡ്-ലൈൻ ഇന്റർഫേസ് (CLI)
ഇപ്പോൾ നമുക്ക് എല്ലാ പ്രധാന ഫംഗ്ഷനുകളും ഉണ്ട്, അവയെ ഒരുമിച്ച് ഒരു ലളിതമായ, ഉപയോഗയോഗ്യമായ കമാൻഡ്-ലൈൻ ടൂളിലേക്ക് മാറ്റാം. ലോജിക് ഉൾക്കൊള്ളിക്കാൻ നമ്മൾ ഒരു `Wallet` ക്ലാസ്സ് നിർമ്മിക്കുകയും ഉപയോക്തൃ കമാൻഡുകൾ കൈകാര്യം ചെയ്യാൻ പൈത്തണിന്റെ `argparse` മൊഡ്യൂൾ ഉപയോഗിക്കുകയും ചെയ്യും.
നമ്മുടെ എല്ലാ ഫംഗ്ഷനുകളെയും ഒരു സംയോജിത ആപ്ലിക്കേഷനിലേക്ക് സമന്വയിപ്പിക്കുന്ന ഒരു സമ്പൂർണ്ണ സ്ക്രിപ്റ്റ് താഴെ നൽകുന്നു.
```python #!/usr/bin/env python3 import os import hashlib import base58 import ecdsa import argparse from sha3 import keccak_256 class Wallet: """കീ മാനേജ്മെന്റും അഡ്രസ്സ് ജനറേഷനുമുള്ള ഒരു ക്രിപ്‌റ്റോകറൻസി വാലറ്റിനെ പ്രതിനിധീകരിക്കുന്നു.""" def __init__(self, private_key_hex=None): if private_key_hex: self.private_key = bytes.fromhex(private_key_hex) else: self.private_key = self._generate_private_key() self.public_key = self._private_to_public_key(self.private_key) self.btc_address = self._public_to_btc_address(self.public_key) self.eth_address = self._public_to_eth_address(self.public_key) def _generate_private_key(self): return os.urandom(32) def _private_to_public_key(self, private_key): sk = ecdsa.SigningKey.from_string(private_key, curve=ecdsa.SECP256k1) return sk.verifying_key.to_string("uncompressed") def _public_to_btc_address(self, public_key): sha256_hash = hashlib.sha256(public_key).digest() ripemd160 = hashlib.new('ripemd160') ripemd160.update(sha256_hash) hashed_pk = ripemd160.digest() versioned_hash = b'\x00' + hashed_pk checksum = hashlib.sha256(hashlib.sha256(versioned_hash).digest()).digest()[:4] binary_address = versioned_hash + checksum return base58.b58encode(binary_address).decode('utf-8') def _public_to_eth_address(self, public_key): uncompressed_pk = public_key[1:] keccak_hash = keccak_256(uncompressed_pk).digest() return '0x' + keccak_hash[-20:].hex() def display_details(self): print(f"Private Key (hex): {self.private_key.hex()}") print(f"Public Key (hex): {self.public_key.hex()}") print(f"Bitcoin Address: {self.btc_address}") print(f"Ethereum Address: {self.eth_address}") def main(): parser = argparse.ArgumentParser(description="ഒരു ലളിതമായ കമാൻഡ്-ലൈൻ ക്രിപ്‌റ്റോകറൻസി വാലറ്റ്.") parser.add_argument("command", choices=["create", "details"], help="നിർവ്വഹിക്കേണ്ട കമാൻഡ്.") parser.add_argument("--privatekey", help="വിശദാംശങ്ങൾ ലഭിക്കുന്നതിനായി നിലവിലുള്ള ഒരു പ്രൈവറ്റ് കീ ഹെക്സ് ഫോർമാറ്റിൽ.") args = parser.parse_args() if args.command == "create": wallet = Wallet() print("--- പുതിയ വാലറ്റ് നിർമ്മിച്ചു ---") wallet.display_details() print("\n*** പ്രധാനം ***") print("നിങ്ങളുടെ പ്രൈവറ്റ് കീ സുരക്ഷിതമായ ഒരു സ്ഥലത്ത് സൂക്ഷിക്കുക. നിങ്ങളുടെ ഫണ്ടുകൾ ആക്സസ് ചെയ്യാനുള്ള ഒരേയൊരു മാർഗ്ഗം അതാണ്.") elif args.command == "details": if not args.privatekey: print("പിശക്: 'details' കമാൻഡിന് --privatekey ഫ്ലാഗ് ഉപയോഗിച്ച് ഒരു പ്രൈവറ്റ് കീ ആവശ്യമാണ്.") return try: wallet = Wallet(private_key_hex=args.privatekey) print("--- വാലറ്റ് വിശദാംശങ്ങൾ ---") wallet.display_details() except Exception as e: print(f"പ്രൈവറ്റ് കീയിൽ നിന്ന് വാലറ്റ് ലോഡ് ചെയ്യുന്നതിൽ പിശക്: {e}") if __name__ == "__main__": main() ```ഈ CLI ടൂൾ എങ്ങനെ ഉപയോഗിക്കാം:
- മുകളിലുള്ള കോഡ് ഒരു പൈത്തൺ ഫയലായി സേവ് ചെയ്യുക (ഉദാഹരണത്തിന്, `cli_wallet.py`).
- നിങ്ങളുടെ ടെർമിനൽ അല്ലെങ്കിൽ കമാൻഡ് പ്രോംപ്റ്റ് തുറക്കുക.
- ഒരു പുതിയ വാലറ്റ് നിർമ്മിക്കാൻ: `python cli_wallet.py create`
- നിലവിലുള്ള ഒരു പ്രൈവറ്റ് കീയിൽ നിന്നുള്ള വിശദാംശങ്ങൾ കാണുന്നതിന്: `python cli_wallet.py details --privatekey YOUR_PRIVATE_KEY_IN_HEX`
സുരക്ഷാ മികച്ച രീതികളും പ്രധാന പരിഗണനകളും
നമ്മൾ ഒരു അടിസ്ഥാന വാലറ്റ് വിജയകരമായി നിർമ്മിച്ചു, എന്നാൽ ഒരു പ്രൊഡക്ഷൻ-റെഡി ആപ്ലിക്കേഷന് സുരക്ഷയിൽ കൂടുതൽ ആഴത്തിലുള്ള ശ്രദ്ധ ആവശ്യമാണ്. പരിഗണിക്കേണ്ട ചില നിർണായക കാര്യങ്ങൾ ഇതാ.
1. പ്രൈവറ്റ് കീകൾ ഒരിക്കലും പ്ലെയിൻ ടെക്സ്റ്റിൽ സൂക്ഷിക്കരുത്
നമ്മുടെ സ്ക്രിപ്റ്റ് പ്രൈവറ്റ് കീ കൺസോളിലേക്ക് പ്രിന്റ് ചെയ്യുന്നു, ഇത് വളരെ സുരക്ഷിതമല്ലാത്ത ഒരു രീതിയാണ്. ഒരു യഥാർത്ഥ ആപ്ലിക്കേഷനിൽ, പ്രൈവറ്റ് കീകൾ ഒരു ശക്തമായ പാസ്‌വേർഡ് ഉപയോഗിച്ച് എൻക്രിപ്റ്റ് ചെയ്ത് സൂക്ഷിക്കണം. ഒപ്പുവെക്കാൻ ആവശ്യമുള്ളപ്പോൾ മാത്രം അവ മെമ്മറിയിൽ ഡീക്രിപ്റ്റ് ചെയ്യണം. പ്രൊഫഷണൽ സൊല്യൂഷനുകൾ പലപ്പോഴും കീകൾ സംരക്ഷിക്കാൻ ഹാർഡ്‌വെയർ സെക്യൂരിറ്റി മൊഡ്യൂളുകൾ (HSMs) അല്ലെങ്കിൽ ഉപകരണങ്ങളിലെ സുരക്ഷിത എൻക്ലേവുകൾ ഉപയോഗിക്കുന്നു.
2. എൻട്രോപ്പിയുടെ പ്രാധാന്യം
നിങ്ങളുടെ വാലറ്റിന്റെ സുരക്ഷ ആരംഭിക്കുന്നത് പ്രൈവറ്റ് കീ ജനറേറ്റ് ചെയ്യാൻ ഉപയോഗിക്കുന്ന റാൻഡംനെസ്സിൽ (എൻട്രോപ്പി) നിന്നാണ്. മിക്ക ആധുനിക ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളിലും `os.urandom` ഒരു നല്ല ഉറവിടമാണ്, എന്നാൽ ഉയർന്ന മൂല്യമുള്ള ആപ്ലിക്കേഷനുകൾക്ക്, ഡെവലപ്പർമാർ പ്രവചനാതീതത ഉറപ്പാക്കാൻ ഒന്നിലധികം ഉറവിടങ്ങളിൽ നിന്ന് എൻട്രോപ്പി ശേഖരിക്കാറുണ്ട്.
3. മെമ്മോണിക് ഫ്രെയ്സുകൾ (സീഡ് ഫ്രെയ്സുകൾ) - വ്യവസായ നിലവാരം
നീണ്ട ഹെക്സാഡെസിമൽ പ്രൈവറ്റ് കീകൾ സ്വമേധയാ ബാക്കപ്പ് ചെയ്യുന്നത് ബുദ്ധിമുട്ടുള്ളതും പിശകുകൾക്ക് സാധ്യതയുള്ളതുമാണ്. ഹൈറാർക്കിക്കൽ ഡിറ്റർമിനിസ്റ്റിക് (HD) വാലറ്റുകളും (BIP-32-ൽ നിർവചിച്ചിരിക്കുന്നത്) മെമ്മോണിക് ഫ്രെയ്സുകളും (BIP-39) ഉപയോഗിച്ച് വ്യവസായം ഇത് പരിഹരിച്ചു. ഒരു മെമ്മോണിക് ഫ്രെയ്സ് എന്നത് 12-24 സാധാരണ വാക്കുകളുടെ ഒരു ശ്രേണിയാണ്, അത് നിങ്ങളുടെ മാസ്റ്റർ പ്രൈവറ്റ് കീയും തുടർന്നുള്ള എല്ലാ കീകളും ഡിറ്റർമിനിസ്റ്റിക്കായി പുനരുജ്ജീവിപ്പിക്കാൻ ഉപയോഗിക്കാം. ഇത് വാലറ്റ് ബാക്കപ്പും വീണ്ടെടുക്കലും കൂടുതൽ ഉപയോക്തൃ-സൗഹൃദമാക്കുന്നു.
4. ഇത് ഒരു വിദ്യാഭ്യാസപരമായ ഉപകരണം, ഒരു പ്രൊഡക്ഷൻ വാലറ്റല്ല
ഈ നിർവ്വഹണം ഒരു ലളിതമായ മാതൃകയാണെന്ന് ആവർത്തിക്കേണ്ടത് അത്യാവശ്യമാണ്. ഒരു യഥാർത്ഥ ലോക വാലറ്റിന് ഒന്നിലധികം അഡ്രസ്സുകൾ കൈകാര്യം ചെയ്യേണ്ടതുണ്ട്, ബാലൻസുകൾ ലഭിക്കുന്നതിനും ഇടപാടുകൾ നിർമ്മിക്കുന്നതിനും ബ്ലോക്ക്ചെയിൻ നോഡുകളുമായി സംവദിക്കേണ്ടതുണ്ട്, ഫീസ് കണക്കാക്കുകയും ഒപ്പിട്ട ഇടപാടുകൾ നെറ്റ്‌വർക്കിലേക്ക് പ്രക്ഷേപണം ചെയ്യുകയും വേണം. ഇതിന് ഒരു സുരക്ഷിതമായ ഉപയോക്തൃ ഇന്റർഫേസും ശക്തമായ പിശക് കൈകാര്യം ചെയ്യലും ആവശ്യമാണ്.
5. നെറ്റ്‌വർക്ക് ആശയവിനിമയം
നമ്മുടെ വാലറ്റിന് കീകൾ ജനറേറ്റ് ചെയ്യാനും സന്ദേശങ്ങളിൽ ഒപ്പിടാനും കഴിയും, പക്ഷേ ഇതിന് ഒരു ബ്ലോക്ക്ചെയിൻ നെറ്റ്‌വർക്കുമായി ആശയവിനിമയം നടത്താൻ കഴിയില്ല. ഒരു പൂർണ്ണമായ ആപ്ലിക്കേഷൻ നിർമ്മിക്കുന്നതിന്, RPC (റിമോട്ട് പ്രൊസീജ്യർ കോൾ) വഴി ബ്ലോക്ക്ചെയിൻ നോഡുകളിലേക്ക് കണക്റ്റുചെയ്യാൻ കഴിയുന്ന ലൈബ്രറികൾ നിങ്ങൾ സംയോജിപ്പിക്കേണ്ടതുണ്ട്. എതെറിയത്തിന്, `web3.py` ആണ് സ്റ്റാൻഡേർഡ് ലൈബ്രറി. ബിറ്റ്കോയിനിനായി, `python-bitcoinlib` പോലുള്ള ലൈബ്രറികൾ ഉപയോഗിക്കാം.
ഉപസംഹാരവും അടുത്ത ഘട്ടങ്ങളും
അഭിനന്ദനങ്ങൾ! പൈത്തൺ ഉപയോഗിച്ച് ഒരു ക്രിപ്‌റ്റോകറൻസി വാലറ്റിന്റെ ക്രിപ്റ്റോഗ്രാഫിക് കോർ നിങ്ങൾ വിജയകരമായി നിർമ്മിച്ചു. പബ്ലിക്/പ്രൈവറ്റ് കീ ക്രിപ്റ്റോഗ്രഫിയുടെ അടിസ്ഥാന സിദ്ധാന്തത്തിൽ നിന്ന് ബിറ്റ്കോയിൻ, എതെറിയം നെറ്റ്‌വർക്കുകൾക്ക് സാധുവായ അഡ്രസ്സുകൾ നിർമ്മിക്കുന്ന ഒരു പ്രായോഗിക നിർവ്വഹണത്തിലേക്ക് നമ്മൾ യാത്ര ചെയ്തു.
ഈ പ്രോജക്റ്റ് ബ്ലോക്ക്ചെയിൻ സാങ്കേതികവിദ്യയുടെ ആഴത്തിലുള്ള പര്യവേക്ഷണത്തിന് ശക്തമായ ഒരു അടിത്തറ നൽകുന്നു. ഒരു വാലറ്റ്, അതിന്റെ കാതൽ, തെളിയിക്കപ്പെട്ട ക്രിപ്റ്റോഗ്രാഫിക് തത്വങ്ങളെ അടിസ്ഥാനമാക്കി നിർമ്മിച്ച ഒരു സങ്കീർണ്ണമായ കീ മാനേജ്മെന്റ് സിസ്റ്റമാണെന്ന് നിങ്ങൾ നേരിട്ട് കണ്ടു.
ഇവിടെ നിന്ന് നിങ്ങൾ എവിടെ പോകുന്നു? നിങ്ങളുടെ അടുത്ത ഘട്ടങ്ങളായി ഈ വെല്ലുവിളികൾ പരിഗണിക്കുക:
- HD വാലറ്റുകൾ നടപ്പിലാക്കുക: ഒരൊറ്റ മെമ്മോണിക് സീഡ് ഫ്രെയ്സിൽ നിന്ന് ദശലക്ഷക്കണക്കിന് അഡ്രസ്സുകൾ കൈകാര്യം ചെയ്യാൻ കഴിയുന്ന ഒരു വാലറ്റ് നിർമ്മിക്കാൻ BIP-32, BIP-39, BIP-44 മാനദണ്ഡങ്ങൾ പര്യവേക്ഷണം ചെയ്യുക.
- നെറ്റ്‌വർക്കിലേക്ക് കണക്റ്റുചെയ്യുക: ഒരു എതെറിയം നോഡിലേക്ക് (Infura അല്ലെങ്കിൽ Alchemy പോലുള്ളവ) കണക്റ്റുചെയ്യാനും, ഒരു അഡ്രസ്സ് ബാലൻസ് പരിശോധിക്കാനും, ഒരു റോ ഇടപാട് നിർമ്മിക്കാനും `web3.py` ഉപയോഗിക്കുക.
- ഒരു യൂസർ ഇന്റർഫേസ് നിർമ്മിക്കുക: നിങ്ങളുടെ വാലറ്റ് കൂടുതൽ ഉപയോക്തൃ-സൗഹൃദമാക്കാൻ Tkinter പോലുള്ള ഒരു ഫ്രെയിംവർക്ക് ഉപയോഗിച്ച് ഒരു ലളിതമായ ഗ്രാഫിക്കൽ യൂസർ ഇന്റർഫേസ് (GUI) അല്ലെങ്കിൽ Flask/Django ഉപയോഗിച്ച് ഒരു വെബ് ഇന്റർഫേസ് നിർമ്മിക്കുക.
- മറ്റ് ബ്ലോക്ക്ചെയിനുകൾ പര്യവേക്ഷണം ചെയ്യുക: മറ്റ് ബ്ലോക്ക്ചെയിൻ പ്ലാറ്റ്‌ഫോമുകൾ എങ്ങനെയാണ് അവരുടെ അഡ്രസ്സുകൾ നിർമ്മിക്കുന്നതെന്ന് അന്വേഷിക്കുകയും അവയെ പിന്തുണയ്ക്കുന്നതിനായി നിങ്ങളുടെ കോഡ് മാറ്റുകയും ചെയ്യുക.
ബ്ലോക്ക്ചെയിനിന്റെ ലോകം ഓപ്പൺ സോഴ്‌സ് സഹകരണത്തിലും അറിവിനായുള്ള ദാഹത്തിലുമാണ് നിർമ്മിച്ചിരിക്കുന്നത്. ഇതുപോലുള്ള ഉപകരണങ്ങൾ നിർമ്മിക്കുന്നതിലൂടെ, നിങ്ങൾ കോഡ് ചെയ്യാൻ പഠിക്കുക മാത്രമല്ല ചെയ്യുന്നത്—നിങ്ങൾ ഒരു പുതിയ ഡിജിറ്റൽ സമ്പദ്‌വ്യവസ്ഥയുടെ ഭാഷ പഠിക്കുകയാണ്. പരീക്ഷണം തുടരുക, നിർമ്മാണം തുടരുക, വികേന്ദ്രീകൃത സാങ്കേതികവിദ്യയുടെ വിശാലമായ സാധ്യതകൾ പര്യവേക്ഷണം ചെയ്യുന്നത് തുടരുക.